#include <string>
#include <jni.h>
#include "JniTools.h"
#define UTF_8 "UTF-8"
#include <android/log.h>
#define LOG_TAG_Aivin    "C_TAG_Aivin"
#define LOGD(...)  __android_log_print  (ANDROID_LOG_DEBUG,  LOG_TAG_Aivin, __VA_ARGS__)


jstring getNewJstring(JNIEnv* env ,char * msgChar)
{
    jstring last= env->NewStringUTF( msgChar );
    return  last ;
}

jint logJstring(JNIEnv *env  , jstring msgStr)
{
    const char* reslut = env->GetStringUTFChars(msgStr, NULL);
    LOGD("jstring ====== %s"  ,  reslut) ;
    env->ReleaseStringUTFChars(msgStr ,reslut) ;
    return 1 ;
}

/***
 * 字符串拼接
 */

jstring getAppendedString(JNIEnv *env , jstring s1, jstring s2)
{

    const char *s1x = env ->GetStringUTFChars(s1, NULL);
    const char *s2x = env->GetStringUTFChars(s2, NULL);

    char *sall = new char[strlen(s1x) + strlen(s2x) + 1];
    strcpy(sall, s1x);
    strcat(sall, s2x);

    jstring retval = env->NewStringUTF(sall);

    env->ReleaseStringUTFChars(s1, s1x);
    env->ReleaseStringUTFChars(s2, s2x);
    free(sall);

    return retval;

}

/**
 * jbyte数组转为十六进制的 jstring
 */
jstring toHexJstring(JNIEnv *env, jbyteArray digested_bytes)
{
    jclass big_integer_cls = env->FindClass("java/math/BigInteger");
    jmethodID new_big_integer_mid = env->GetMethodID(big_integer_cls, "<init>","(I[B)V");
    jobject big_integer_obj = env->NewObject(big_integer_cls,new_big_integer_mid, 1, digested_bytes);
    env->DeleteLocalRef(digested_bytes);
    jmethodID to_String_mid = env->GetMethodID(big_integer_cls, "toString", "(I)Ljava/lang/String;");
    env->DeleteLocalRef(big_integer_cls);
    return reinterpret_cast<jstring>(env->CallObjectMethod(big_integer_obj, to_String_mid, 16));
}


/***
 * jstring转 jbyteArray
 */
jbyteArray toBytes(JNIEnv *env, jstring string)
{
    jclass string_cls = env->FindClass("java/lang/String");
    jmethodID get_bytes_mid = env->GetMethodID(string_cls, "getBytes", "(Ljava/lang/String;)[B");
    return reinterpret_cast<jbyteArray>(env->CallObjectMethod(string,  get_bytes_mid,  env->NewStringUTF(UTF_8)));
}


///***
// * 获取签名
// */
//jstring getSignatures(JNIEnv *env,    jobject thiz) {
//
////    char* test= "test..." ;
////    return  getNewJstring( env ,test) ;
//
//    jclass native_clazz = env->GetObjectClass(thiz);
//
//    // 得到 getPackageManager 方法的 ID
//    jmethodID methodID_func = env->GetMethodID(native_clazz,  "getPackageManager", "()Landroid/content/pm/PackageManager;");
//
//    // 获得应用包的管理器
//    jobject package_manager = env->CallObjectMethod(thiz, methodID_func);
//
//    // 获得 PackageManager 类
//    jclass pm_clazz = env->GetObjectClass(package_manager);
//
//    // 得到 getPackageInfo 方法的 ID
//    jmethodID methodID_pm = env->GetMethodID(pm_clazz, "getPackageInfo",
//                                             "(Ljava/lang/String;I)Landroid/content/pm/PackageInfo;");
//
//    //获取包名
//    jmethodID methodID_packagename = env->GetMethodID(native_clazz,
//                                                      "getPackageName", "()Ljava/lang/String;");
//    jstring name_str = static_cast<jstring>(env->CallObjectMethod(thiz,
//                                                                  methodID_packagename));
//
//    // 获得应用包的信息
//    jobject package_info = env->CallObjectMethod(package_manager, methodID_pm,
//                                                 name_str,
//                                                 64);        //env->NewStringUTF("com.example.contasdf")
//
//    // 获得 PackageInfo 类
//    jclass pi_clazz = env->GetObjectClass(package_info);
//
//    // 获得签名数组属性的 ID
//    jfieldID fieldID_signatures = env->GetFieldID(pi_clazz, "signatures",
//                                                  "[Landroid/content/pm/Signature;");
//
//    // 得到签名数组，待修改
//    jobject signatur = env->GetObjectField(package_info, fieldID_signatures);
//    jobjectArray signatures = reinterpret_cast<jobjectArray>(signatur);
//    // 得到签名
//    jobject signature = env->GetObjectArrayElement(signatures, 0);
//
//    // 获得 Signature 类，待修改
//    jclass s_clazz = env->GetObjectClass(signature);
//
//    // 得到 hashCode 方法的 ID
//    jmethodID methodID_hc = env->GetMethodID(s_clazz, "hashCode", "()I");
//
//    // 获得应用包的管理器，待修改
//    int hash_code = env->CallIntMethod(signature, methodID_hc);
//
//    char str[100];
//    sprintf(str, "%u", hash_code);
//
//    jstring sign = env->NewStringUTF(str);
//
//    return sign;
//}




jvalue JNU_CallMethodByName(JNIEnv *env, jboolean *hasException, jobject obj,
                            const char *name, const char *descriptor, ...) {
    va_list args;
    jclass clazz;
    jmethodID mid;
    jvalue result;
    if (env->EnsureLocalCapacity(  2) == JNI_OK) {
        clazz = env->GetObjectClass(  obj);
        mid = env->GetMethodID(  clazz, name, descriptor);
        if (mid) {
            const char *p = descriptor;
            /* skip over argument types to find out the
              return type */
            while (*p != ')')
                p++;
            /* skip ')' */
            p++;
            va_start(args, descriptor);
            switch (*p) {
                case 'V':
                    env->CallVoidMethodV(  obj, mid, args);
                    break;
                case '[':
                case 'L':
                    result.l = env->CallObjectMethodV(  obj, mid, args);
                    break;
                case 'Z':
                    result.z = env->CallBooleanMethodV(  obj, mid, args);
                    break;
                case 'B':
                    result.b = env->CallByteMethodV(   obj, mid, args);
                    break;
                case 'C':
                    result.c = env->CallCharMethodV(  obj, mid, args);
                    break;
                case 'S':
                    result.s = env->CallShortMethodV(  obj, mid, args);
                    break;
                case 'I':
                    result.i = env->CallIntMethodV(  obj, mid, args);
                    break;
                case 'J':
                    result.j = env->CallLongMethodV(  obj, mid, args);
                    break;
                case 'F':
                    result.f = env->CallFloatMethodV(  obj, mid, args);
                    break;
                case 'D':
                    result.d = env->CallDoubleMethodV(  obj, mid, args);
                    break;
                default:
                    env->FatalError(  "illegaldescriptor");
            }
            va_end(args);
        }
        env->DeleteLocalRef(  clazz);
    }
    if (hasException) {
        *hasException = env->ExceptionCheck( );
    }
    return result;
}






////
//// Created by Aivin on 2017/10/6.
////
//
//#include "../../../../../../aivin_soft/sdk/ndk-bundle/platforms/android-21/arch-arm/usr/include/jni.h"
//#include "../../../../../../aivin_soft/sdk/ndk-bundle/platforms/android-21/arch-arm/usr/include/string.h"
//#include "JniTools.h"
//#include "../../../../../../aivin_soft/sdk/ndk-bundle/platforms/android-21/arch-arm/usr/include/stdio.h"
//
//jstring JniTools::stoJstring(JNIEnv *env , char* chars)
//{
//    jclass strClass = env->FindClass("Ljava/lang/String;");
//    jmethodID ctorID = env->GetMethodID(strClass, "<init>", "([BLjava/lang/String;)V");
//    jbyteArray bytes = env->NewByteArray(strlen(chars));
//    env->SetByteArrayRegion(bytes, 0, strlen(chars), (jbyte*)chars);
//    jstring encoding = env->NewStringUTF("utf-8");
//    return (jstring)env->NewObject(strClass, ctorID, bytes, encoding);
//}
//
//
//
//
//
//
//
///**
// * 从二进制的.class的数据缓冲区中加载类
// *
// * @param env JNI接口指针
// * @param name UTF8编码的需要加载的类的名字
// * @param loader 类加载器
// * @param buf 包含.class字节码的数组
// * @param bufLen 长度
// *
// * @return class对象或NULL
// *
// * @throws ClassFormatError 不是有效的class数据
// * @throws ClassCircularityError 类或接口是自身的父类或自身继承了该接口
// * @throws OutOfMemoryError 内存不足
// * @throws SecurityException 如果该类是属于java包的
// */
//jclass (*DefineClass)(JNIEnv *, const char *, jobject, const jbyte *, jsize);
//
//
///**
// * 用于加载本地定义的类
// *
// * @param env JNI接口指针
// * @param name 完整的包名("/"代替".") 或 数组类型字段描述("["开头，紧跟签名描述)，如"java/lang/String" for java.lang.String, "[Ljava/lang/Object;" for java.lang.Object[]
// *
// * @return class对象或NULL
// *
// * @throws ClassFormatError 不是有效的class数据
// * @throws ClassCircularityError 类或接口是自身的父类或自身继承了该接口
// * @throws OutOfMemoryError 内存不足
// * @throws NoClassDefFoundError 找不到name对应的class类
// */
//jclass (*FindClass)(JNIEnv *, const char *);
//
//
///**
// * 从java.lang.reflect.Method 或 java.lang.reflect.Constructor 获取method ID
// *
// * @param env JNI接口指针
// * @param method java.lang.reflect.Method 或 java.lang.reflect.Constructor对象
// *
// * @return 方法ID
// */
//jmethodID (*FromReflectedMethod)(JNIEnv *, jobject);
//
//
///**
// * 从java.lang.reflect.Field获取field ID
// *
// * @param env JNI接口指针
// * @param field java.lang.reflect.Field对象
// *
// * @return field ID
// */
//jfieldID (*FromReflectedField)(JNIEnv *, jobject);
//
//
///**
// * 从method ID获取 java.lang.reflect.Method 或 java.lang.reflect.Constructor 对象
// *
// * @param env JNI接口指针
// * @param cls 该方法的类对象
// * @param methodID 方法ID
// * @param isStatic 是否静态方法
// *
// * @return java.lang.reflect.Method 或 java.lang.reflect.Constructor 对象
// *
// * @throws OutOfMemoryError 内存不足
// */
//jobject (*ToReflectedMethod)(JNIEnv *, jclass, jmethodID, jboolean);
//
//
///**
// * 如果clazz不是class对象或接口，则返回该class的超类
// *
// * @param env JNI接口指针
// * @param clazz class对象
// *
// * @return 返回输入类的父类 或 NULL
// */
//jclass (*GetSuperclass)(JNIEnv *, jclass);
//
//
///**
// * class1是否可以安全地转换为class2，以下三种情况会返回TRUE
// * 1. 当class1和class2是同一个java class的引用
// * 2. class1是class2的子类
// * 3. class2是class1的某个接口
// *
// * @param env JNI接口指针
// * @param clazz1 class1
// * @param clazz2 class2
// *
// * @return JNI_TRUE or JNI_FALSE
// */
//jboolean (*IsAssignableFrom)(JNIEnv *, jclass, jclass);
//
//
///**
// * 根据 field ID 获取 java.lang.reflect.Field 对象
// *
// * @param env JNI接口指针
// * @param cls 该方法的类对象
// * @param fieldID 字段ID
// * @param isStatic 是否静态变量
// *
// * @return java.lang.reflect.Field 对象
// *
// * @throws OutOfMemoryError 内存不足
// */
//jobject (*ToReflectedField)(JNIEnv *, jclass, jfieldID, jboolean);
//
//
///**
// * 抛出异常
// *
// * @param env JNI接口指针
// * @param obj java.lang.Throwable 对象
// *
// * @return 0：成功， 负数：失败
// *
// * @throws Throwable
// */
//jint (*Throw)(JNIEnv *, jthrowable);
//
//
///**
// * 根据clazz和message构造一个异常对象，并将它抛出
// *
// * @param env JNI接口指针
// * @param clazz java.lang.Throwable的子类
// * @param message 错误信息
// *
// * @return 0：成功， 负数：失败
// *
// * @throws Throwable
// */
//jint (*ThrowNew)(JNIEnv *, jclass, const char *);
//
//
///**
// * 判断是否有异常抛出，在调用ExceptionClear()或java代码处理了exception之前，都可以用这个方法判断是否有异常
// *
// * @param env JNI接口指针
// *
// * @return 异常对象 or NULL
// */
//jthrowable (*ExceptionOccurred)(JNIEnv *);
//
//
///**
// * 打印异常信息
// *
// * @param env JNI接口指针
// */
//void (*ExceptionDescribe)(JNIEnv *);
//
//
///**
// * 清除所有已抛出的异常
// *
// * @param env JNI接口指针
// */
//void (*ExceptionClear)(JNIEnv *);
//
//
///**
// * 抛出致命错误并且不希望虚拟机进行恢复。无返回值
// *
// * @param env JNI接口指针
// * @param msg 错误信息
// */
//void (*FatalError)(JNIEnv *, const char *);
//
//
///**
// * 创建一个新的本地引用帧
// *
// * @param env JNI接口指针
// * @param capacity 容量
// *
// * @return 0：成功，负数：失败
// *
// * @throws OutOfMemoryError
// */
//jint (*PushLocalFrame)(JNIEnv *, jint);
//
//
///**
// * 弹出当前本地引用帧，释放所有本地引用
// *
// * @param env JNI接口指针
// * @param result
// *
// * @return
// */
//jobject (*PopLocalFrame)(JNIEnv *, jobject);
//
//
///**
// * 为传入的obj创建全局引用，obj可以是全局引用也可以是局部引用。全局引用需要调用DeleteGlobalRef来释放
// *
// * @param env JNI接口指针
// * @param obj 全局或局部引用
// *
// * @return 全局引用 or NULL(内存不足)
// */
//jobject (*NewGlobalRef)(JNIEnv *, jobject);
//
//
///**
// * 释放全局引用
// *
// * @param env JNI接口指针
// * @param globalRef 全局引用
// */
//void (*DeleteGlobalRef)(JNIEnv *, jobject);
//
//
///**
// * 释放局部引用
// *
// * @param env JNI接口指针
// * @param localRef 局部引用
// */
//void (*DeleteLocalRef)(JNIEnv *, jobject);
//
//
///**
// * 判断两个引用是否同一java对象的引用
// *
// * @param env JNI接口指针
// * @param ref1 引用1
// * @param ref2 引用2
// *
// * @return JNI_TRUE:两个引用指向同一个java对象
// */
//jboolean (*IsSameObject)(JNIEnv *, jobject, jobject);
//
//
///**
// * 为传入的ref创建局部引用，ref可以是全局引用也可以是局部引用
// *
// * @param env JNI接口指针
// * @param ref 全局或局部引用
// *
// * @return 局部引用 or NULL
// */
//jobject (*NewLocalRef)(JNIEnv *, jobject);
//
//
///**
// * 确保当前线程可以创建capacity个局部引用。在进入本地方法时，VM确保可以可以创建最少16个局部引用
// *
// * @param env JNI接口指针
// * @param capacity 局部引用个数
// *
// * @return 0：成功，负数：失败
// *
// * @throws OutOfMemoryError 内存不足
// */
//jint (*EnsureLocalCapacity)(JNIEnv *, jint);
//
//
///**
// * 创建一个新的java对象（不会调用对象的构造方法）
// *
// * @param env JNI接口指针
// * @param clazz 非数组class对象
// *
// * @return java对象
// *
// * @throws InstantiationException clazz是一个接口或抽象类
// * @throws OutOfMemoryError 内存不足
// */
//jobject (*AllocObject)(JNIEnv *, jclass);
//
//
///**
// * 构造一个新的java对象，method ID指用以生成该类的构造方法，method ID必须是通过GetMethodID()获得
// *
// * @param env JNI接口指针
// * @param clazz 非数组class对象
// * @param ... 传递给构造方法的参数
// *
// * @return java对象 or NULL(对象构造失败)
// *
// * @throws InstantiationException clazz是一个接口或抽象类
// * @throws OutOfMemoryError 内存不足
// */
//jobject (*NewObject)(JNIEnv *, jclass, jmethodID, ...);
//
//
///**
// * 构造一个新的java对象，method ID指用以生成该类的构造方法，method ID必须是通过GetMethodID()获得
// *
// * @param env JNI接口指针
// * @param clazz 非数组class对象
// * @param args va_list结构，里面有传递给构造方法的参数
// *
// * @return java对象 or NULL(对象构造失败)
// *
// * @throws InstantiationException clazz是一个接口或抽象类
// * @throws OutOfMemoryError 内存不足
// */
//jobject (*NewObjectV)(JNIEnv *, jclass, jmethodID, va_list);
//
//
///**
// * 构造一个新的java对象，method ID指用以生成该类的构造方法，method ID必须是通过GetMethodID()获得
// *
// * @param env JNI接口指针
// * @param clazz 非数组class对象
// * @param args 参数数组，里面是传递给构造方法的参数
// *
// * @return java对象 or NULL(对象构造失败)
// *
// * @throws InstantiationException clazz是一个接口或抽象类
// * @throws OutOfMemoryError 内存不足
// */
//jobject (*NewObjectA)(JNIEnv *, jclass, jmethodID, jvalue *);
//
//
///**
// * 返回对象对应的class对象
// *
// * @param env JNI接口指针
// * @param obj 非空java对象
// *
// * @return class对象
// */
//jclass (*GetObjectClass)(JNIEnv *, jobject);
//
//
///**
// * 判断obj是否clazz的实例对象
// *
// * @param env JNI接口指针
// * @param obj java对象
// * @param clazz class对象
// *
// * @return
// */
//jboolean (*IsInstanceOf)(JNIEnv *, jobject, jclass);
//
//
///**
// * 返回非静态方法的method ID
// *
// * @param env JNI接口指针
// * @param clazz class对象
// * @param name 方法名
// * @param sig 方法签名
// *
// * @return 方法ID or NULL
// *
// * @throws NoSuchMethodError 找不到对应的方法
// * @throws ExceptionInInitializerError class初始化失败
// * @throws OutOfMemoryError 内存不足
// */
//jmethodID (*GetMethodID)(JNIEnv *, jclass, const char *, const char *);
//
//
///**
// * Call<type>Method(JNIEnv *env, jobject obj, jmethodID methodID, ...);调用参数放到可变参数中
// * Call<type>MethodA(JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);调用参数放入jvalue数组
// * Call<type>MethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args);调用参数放入va_list结构中
// *
// * 以上三组调用接口都是根据 method ID调用java实例方法（非静态方法）的接口，其中method ID是通过GetMethodID()获取的
// * 当这些方法用于调用java对象的私有方法或构造函数时，method ID必须从obj的真实类获取，而不应从其某个父类获取
// * <type>是方法的返回类型，三类接口间唯一的区别是methodID参数之后调用参数的不同
// *
// *
// * @param env JNI接口指针
// * @param obj java对象
// * @param methodID 方法ID
// * @param args 调用参数
// *
// * @return java方法返回结果
// *
// * @throws java方法中可能抛出的异常
// */
//jobject (*CallObjectMethod)(JNIEnv *, jobject, jmethodID, ...);
//jobject (*CallObjectMethodV)(JNIEnv *, jobject, jmethodID, va_list);
//jobject (*CallObjectMethodA)(JNIEnv *, jobject, jmethodID, jvalue *);
//jboolean (*CallBooleanMethod)(JNIEnv *, jobject, jmethodID, ...);
//jboolean (*CallBooleanMethodV)(JNIEnv *, jobject, jmethodID, va_list);
//jboolean (*CallBooleanMethodA)(JNIEnv *, jobject, jmethodID, jvalue *);
//jbyte (*CallByteMethod)(JNIEnv *, jobject, jmethodID, ...);
//jbyte (*CallByteMethodV)(JNIEnv *, jobject, jmethodID, va_list);
//jbyte (*CallByteMethodA)(JNIEnv *, jobject, jmethodID, jvalue *);
//jchar (*CallCharMethod)(JNIEnv *, jobject, jmethodID, ...);
//jchar (*CallCharMethodV)(JNIEnv *, jobject, jmethodID, va_list);
//jchar (*CallCharMethodA)(JNIEnv *, jobject, jmethodID, jvalue *);
//jshort (*CallShortMethod)(JNIEnv *, jobject, jmethodID, ...);
//jshort (*CallShortMethodV)(JNIEnv *, jobject, jmethodID, va_list);
//jshort (*CallShortMethodA)(JNIEnv *, jobject, jmethodID, jvalue *);
//jint (*CallIntMethod)(JNIEnv *, jobject, jmethodID, ...);
//jint (*CallIntMethodV)(JNIEnv *, jobject, jmethodID, va_list);
//jint (*CallIntMethodA)(JNIEnv *, jobject, jmethodID, jvalue *);
//jlong (*CallLongMethod)(JNIEnv *, jobject, jmethodID, ...);
//jlong (*CallLongMethodV)(JNIEnv *, jobject, jmethodID, va_list);
//jlong (*CallLongMethodA)(JNIEnv *, jobject, jmethodID, jvalue *);
//jfloat (*CallFloatMethod)(JNIEnv *, jobject, jmethodID, ...);
//jfloat (*CallFloatMethodV)(JNIEnv *, jobject, jmethodID, va_list);
//jfloat (*CallFloatMethodA)(JNIEnv *, jobject, jmethodID, jvalue *);
//jdouble (*CallDoubleMethod)(JNIEnv *, jobject, jmethodID, ...);
//jdouble (*CallDoubleMethodV)(JNIEnv *, jobject, jmethodID, va_list);
//jdouble (*CallDoubleMethodA)(JNIEnv *, jobject, jmethodID, jvalue *);
//void (*CallVoidMethod)(JNIEnv *, jobject, jmethodID, ...);
//void (*CallVoidMethodV)(JNIEnv *, jobject, jmethodID, va_list);
//void (*CallVoidMethodA)(JNIEnv *, jobject, jmethodID, jvalue *);
//
//
///**
// * CallNonvirtual<type>Method(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);调用参数放到可变参数中
// * CallNonvirtual<type>MethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, const jvalue *args);调用参数放入jvalue数组
// * CallNonvirtual<type>MethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args);调用参数放入va_list结构中
// *
// * 以上三组调用接口都是根据 method ID 和 class 调用java实例方法（非静态方法）的接口，其中method ID是基于clazz通过GetMethodID()获取的
// * <type>是方法的返回类型，三类接口间唯一的区别是methodID参数之后调用参数的不同
// * 注意，和Call<type>Method不同，如果子类重写了父类的方法，Call<type>Method调用的是子类的方法，如果想调用父类的方法，
// * 则需要用CallNonvirtual<type>Method，这个方法可以传入父类的class和父类的method id，从而达到调用父类方法的效果
// *
// *
// * @param env JNI接口指针
// * @param clazz class对象
// * @param obj java对象
// * @param methodID 方法ID
// * @param args 调用参数
// *
// * @return java方法返回结果
// *
// * @throws java方法中可能抛出的异常
// */
//jobject (*CallNonvirtualObjectMethod)(JNIEnv *, jobject, jclass, jmethodID, ...);
//jobject (*CallNonvirtualObjectMethodV)(JNIEnv *, jobject, jclass, jmethodID, va_list);
//jobject (*CallNonvirtualObjectMethodA)(JNIEnv *, jobject, jclass, jmethodID, jvalue *);
//jboolean (*CallNonvirtualBooleanMethod)(JNIEnv *, jobject, jclass, jmethodID, ...);
//jboolean (*CallNonvirtualBooleanMethodV)(JNIEnv *, jobject, jclass, jmethodID, va_list);
//jboolean (*CallNonvirtualBooleanMethodA)(JNIEnv *, jobject, jclass, jmethodID, jvalue *);
//jbyte (*CallNonvirtualByteMethod)(JNIEnv *, jobject, jclass, jmethodID, ...);
//jbyte (*CallNonvirtualByteMethodV)(JNIEnv *, jobject, jclass, jmethodID, va_list);
//jbyte (*CallNonvirtualByteMethodA)(JNIEnv *, jobject, jclass, jmethodID, jvalue *);
//jchar (*CallNonvirtualCharMethod)(JNIEnv *, jobject, jclass, jmethodID, ...);
//jchar (*CallNonvirtualCharMethodV)(JNIEnv *, jobject, jclass, jmethodID, va_list);
//jchar (*CallNonvirtualCharMethodA)(JNIEnv *, jobject, jclass, jmethodID, jvalue *);
//jshort (*CallNonvirtualShortMethod)(JNIEnv *, jobject, jclass, jmethodID, ...);
//jshort (*CallNonvirtualShortMethodV)(JNIEnv *, jobject, jclass, jmethodID, va_list);
//jshort (*CallNonvirtualShortMethodA)(JNIEnv *, jobject, jclass, jmethodID, jvalue *);
//jint (*CallNonvirtualIntMethod)(JNIEnv *, jobject, jclass, jmethodID, ...);
//jint (*CallNonvirtualIntMethodV)(JNIEnv *, jobject, jclass, jmethodID, va_list);
//jint (*CallNonvirtualIntMethodA)(JNIEnv *, jobject, jclass, jmethodID, jvalue *);
//jlong (*CallNonvirtualLongMethod)(JNIEnv *, jobject, jclass, jmethodID, ...);
//jlong (*CallNonvirtualLongMethodV)(JNIEnv *, jobject, jclass, jmethodID, va_list);
//jlong (*CallNonvirtualLongMethodA)(JNIEnv *, jobject, jclass, jmethodID, jvalue *);
//jfloat (*CallNonvirtualFloatMethod)(JNIEnv *, jobject, jclass, jmethodID, ...);
//jfloat (*CallNonvirtualFloatMethodV)(JNIEnv *, jobject, jclass, jmethodID, va_list);
//jfloat (*CallNonvirtualFloatMethodA)(JNIEnv *, jobject, jclass, jmethodID, jvalue *);
//jdouble (*CallNonvirtualDoubleMethod)(JNIEnv *, jobject, jclass, jmethodID, ...);
//jdouble (*CallNonvirtualDoubleMethodV)(JNIEnv *, jobject, jclass, jmethodID, va_list);
//jdouble (*CallNonvirtualDoubleMethodA)(JNIEnv *, jobject, jclass, jmethodID, jvalue *);
//void (*CallNonvirtualVoidMethod)(JNIEnv *, jobject, jclass, jmethodID, ...);
//void (*CallNonvirtualVoidMethodV)(JNIEnv *, jobject, jclass, jmethodID, va_list);
//void (*CallNonvirtualVoidMethodA)(JNIEnv *, jobject, jclass, jmethodID, jvalue *);
//
//
///**
// * 根据class对象获取非静态成员变量的field ID
// *
// * @param env JNI接口指针
// * @param clazz class对象
// * @param name 变量名
// * @param sig 变量签名
// *
// * @return field ID or NULL
// *
// * @throws NoSuchFieldError 找不到对应的变量ID
// * @throws ExceptionInInitializerError class初始化失败
// * @throws OutOfMemoryError 内存不足
// */
//jfieldID (*GetFieldID)(JNIEnv *, jclass, const char *, const char *);
//
//
///**
// * 根据field id取出对象中相应的变量值，field Id通过GetFieldID()获取
// *
// * @param env JNI接口指针
// * @param obj java对象
// * @param fieldID 有效的field id
// *
// * @return 相应的变量值
// */
//jobject (*GetObjectField)(JNIEnv *, jobject, jfieldID);
//jboolean (*GetBooleanField)(JNIEnv *, jobject, jfieldID);
//jbyte (*GetByteField)(JNIEnv *, jobject, jfieldID);
//jchar (*GetCharField)(JNIEnv *, jobject, jfieldID);
//jshort (*GetShortField)(JNIEnv *, jobject, jfieldID);
//jint (*GetIntField)(JNIEnv *, jobject, jfieldID);
//jlong (*GetLongField)(JNIEnv *, jobject, jfieldID);
//jfloat (*GetFloatField)(JNIEnv *, jobject, jfieldID);
//jdouble (*GetDoubleField)(JNIEnv *, jobject, jfieldID);
//
//
///**
// * 根据field id为相应的变量设置新的值，field Id通过GetFieldID()获取
// *
// * @param env JNI接口指针
// * @param obj java对象
// * @param fieldID 有效的field id
// * @param value 要设置的值
// */
//void (*SetObjectField)(JNIEnv *, jobject, jfieldID, jobject);
//void (*SetBooleanField)(JNIEnv *, jobject, jfieldID, jboolean);
//void (*SetByteField)(JNIEnv *, jobject, jfieldID, jbyte);
//void (*SetCharField)(JNIEnv *, jobject, jfieldID, jchar);
//void (*SetShortField)(JNIEnv *, jobject, jfieldID, jshort);
//void (*SetIntField)(JNIEnv *, jobject, jfieldID, jint);
//void (*SetLongField)(JNIEnv *, jobject, jfieldID, jlong);
//void (*SetFloatField)(JNIEnv *, jobject, jfieldID, jfloat);
//void (*SetDoubleField)(JNIEnv *, jobject, jfieldID, jdouble);
//
//
///**
// * 返回静态方法的method ID
// *
// * @param env JNI接口指针
// * @param clazz class对象
// * @param name 方法名
// * @param sig 方法签名
// *
// * @return 方法ID or NULL
// *
// * @throws NoSuchMethodError 找不到对应的方法
// * @throws ExceptionInInitializerError class初始化失败
// * @throws OutOfMemoryError 内存不足
// */
//jmethodID (*GetStaticMethodID)(JNIEnv *, jclass, const char *, const char *);
//
//
///**
// * CallStatic<type>Method(JNIEnv *env, jclass clazz, jmethodID methodID, ...);调用参数放到可变参数中
// * CallStatic<type>MethodA(JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);调用参数放入jvalue数组
// * CallStatic<type>MethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);调用参数放入va_list结构中
// *
// * 以上三组调用接口都是根据 method ID调用java静态方法的接口，其中method ID是通过GetStaticMethodID()获取的
// * method ID必须从clazz的真实类获取，而不应从其某个父类获取
// * <type>是方法的返回类型，三类接口间唯一的区别是methodID参数之后调用参数的不同
// *
// *
// * @param env JNI接口指针
// * @param clazz class对象
// * @param methodID 方法ID
// * @param args 调用参数
// *
// * @return java方法返回结果
// *
// * @throws java方法中可能抛出的异常
// */
//jobject (*CallStaticObjectMethod)(JNIEnv *, jclass, jmethodID, ...);
//jobject (*CallStaticObjectMethodV)(JNIEnv *, jclass, jmethodID, va_list);
//jobject (*CallStaticObjectMethodA)(JNIEnv *, jclass, jmethodID, jvalue *);
//jboolean (*CallStaticBooleanMethod)(JNIEnv *, jclass, jmethodID, ...);
//jboolean (*CallStaticBooleanMethodV)(JNIEnv *, jclass, jmethodID, va_list);
//jboolean (*CallStaticBooleanMethodA)(JNIEnv *, jclass, jmethodID, jvalue *);
//jbyte (*CallStaticByteMethod)(JNIEnv *, jclass, jmethodID, ...);
//jbyte (*CallStaticByteMethodV)(JNIEnv *, jclass, jmethodID, va_list);
//jbyte (*CallStaticByteMethodA)(JNIEnv *, jclass, jmethodID, jvalue *);
//jchar (*CallStaticCharMethod)(JNIEnv *, jclass, jmethodID, ...);
//jchar (*CallStaticCharMethodV)(JNIEnv *, jclass, jmethodID, va_list);
//jchar (*CallStaticCharMethodA)(JNIEnv *, jclass, jmethodID, jvalue *);
//jshort (*CallStaticShortMethod)(JNIEnv *, jclass, jmethodID, ...);
//jshort (*CallStaticShortMethodV)(JNIEnv *, jclass, jmethodID, va_list);
//jshort (*CallStaticShortMethodA)(JNIEnv *, jclass, jmethodID, jvalue *);
//jint (*CallStaticIntMethod)(JNIEnv *, jclass, jmethodID, ...);
//jint (*CallStaticIntMethodV)(JNIEnv *, jclass, jmethodID, va_list);
//jint (*CallStaticIntMethodA)(JNIEnv *, jclass, jmethodID, jvalue *);
//jlong (*CallStaticLongMethod)(JNIEnv *, jclass, jmethodID, ...);
//jlong (*CallStaticLongMethodV)(JNIEnv *, jclass, jmethodID, va_list);
//jlong (*CallStaticLongMethodA)(JNIEnv *, jclass, jmethodID, jvalue *);
//jfloat (*CallStaticFloatMethod)(JNIEnv *, jclass, jmethodID, ...);
//jfloat (*CallStaticFloatMethodV)(JNIEnv *, jclass, jmethodID, va_list);
//jfloat (*CallStaticFloatMethodA)(JNIEnv *, jclass, jmethodID, jvalue *);
//jdouble (*CallStaticDoubleMethod)(JNIEnv *, jclass, jmethodID, ...);
//jdouble (*CallStaticDoubleMethodV)(JNIEnv *, jclass, jmethodID, va_list);
//jdouble (*CallStaticDoubleMethodA)(JNIEnv *, jclass, jmethodID, jvalue *);
//void (*CallStaticVoidMethod)(JNIEnv *, jclass, jmethodID, ...);
//void (*CallStaticVoidMethodV)(JNIEnv *, jclass, jmethodID, va_list);
//void (*CallStaticVoidMethodA)(JNIEnv *, jclass, jmethodID, jvalue *);
//
//
///**
// * 根据class对象获取静态成员变量的field ID
// *
// * @param env JNI接口指针
// * @param clazz class对象
// * @param name 变量名
// * @param sig 变量签名
// *
// * @return field ID or NULL
// *
// * @throws NoSuchFieldError 找不到对应的变量ID
// * @throws ExceptionInInitializerError class初始化失败
// * @throws OutOfMemoryError 内存不足
// */
//jfieldID (*GetStaticFieldID)(JNIEnv *, jclass, const char *, const char *);
//
//
///**
// * 根据field id取出对象中相应的变量值，field Id通过GetStaticFieldID()获取
// *
// * @param env JNI接口指针
// * @param clazz class对象
// * @param fieldID 有效的field id
// *
// * @return 相应的静态变量值
// */
//jobject (*GetStaticObjectField)(JNIEnv *, jclass, jfieldID);
//jboolean (*GetStaticBooleanField)(JNIEnv *, jclass, jfieldID);
//jbyte (*GetStaticByteField)(JNIEnv *, jclass, jfieldID);
//jchar (*GetStaticCharField)(JNIEnv *, jclass, jfieldID);
//jshort (*GetStaticShortField)(JNIEnv *, jclass, jfieldID);
//jint (*GetStaticIntField)(JNIEnv *, jclass, jfieldID);
//jlong (*GetStaticLongField)(JNIEnv *, jclass, jfieldID);
//jfloat (*GetStaticFloatField)(JNIEnv *, jclass, jfieldID);
//jdouble (*GetStaticDoubleField)(JNIEnv *, jclass, jfieldID);
//
//
///**
// * 根据field id为相应的静态变量设置新的值，field Id通过GetStaticFieldID()获取
// *
// * @param env JNI接口指针
// * @param clazz class对象
// * @param fieldID 有效的field id
// * @param value 要设置的值
// */
//void (*SetStaticObjectField)(JNIEnv *, jclass, jfieldID, jobject);
//void (*SetStaticBooleanField)(JNIEnv *, jclass, jfieldID, jboolean);
//void (*SetStaticByteField)(JNIEnv *, jclass, jfieldID, jbyte);
//void (*SetStaticCharField)(JNIEnv *, jclass, jfieldID, jchar);
//void (*SetStaticShortField)(JNIEnv *, jclass, jfieldID, jshort);
//void (*SetStaticIntField)(JNIEnv *, jclass, jfieldID, jint);
//void (*SetStaticLongField)(JNIEnv *, jclass, jfieldID, jlong);
//void (*SetStaticFloatField)(JNIEnv *, jclass, jfieldID, jfloat);
//void (*SetStaticDoubleField)(JNIEnv *, jclass, jfieldID, jdouble);
//
//
//
//
//
//
//
//
//
//
//
///**
// * 获取数组元素个数
// *
// * @param env JNI接口指针
// * @param array java数组对象
// *
// * @return 数组长度
// */
//jsize (*GetArrayLength)(JNIEnv *, jarray);
//
//
///**
// * 创建新的elementClass类型数组，所有元素初始值均设为initialElement
// *
// * @param env JNI接口指针
// * @param length 数组大小
// * @param elementClass 数组类型
// * @param initialElement 初始值
// *
// * @return 数组对象 or NULL
// */
//jobjectArray (*NewObjectArray)(JNIEnv *, jsize, jclass, jobject);
//
//
///**
// * 获取对象数组中指定index的值
// *
// * @param env JNI接口指针
// * @param array java数组
// * @param index 索引
// *
// * @return 索引对象的对象
// *
// * @throws ArrayIndexOutOfBoundsException
// */
//jobject (*GetObjectArrayElement)(JNIEnv *, jobjectArray, jsize);
//
//
///**
// * 设置对象数组中指定index的值
// *
// * @param env JNI接口指针
// * @param array java数组
// * @param index 索引
// * @param value 新的值
// *
// * @throws ArrayIndexOutOfBoundsException
// */
//void (*SetObjectArrayElement)(JNIEnv *, jobjectArray, jsize, jobject);
//
//
///**
// * ArrayType New<PrimitiveType>Array(JNIEnv *env, jsize length);
// * 创建基本类型数组对象
// *
// * @param env JNI接口指针
// * @param length 数组大小
// *
// * @return 数组对象 or NULL
// */
//jbooleanArray (*NewBooleanArray)(JNIEnv *, jsize);
//jbyteArray (*NewByteArray)(JNIEnv *, jsize);
//jcharArray (*NewCharArray)(JNIEnv *, jsize);
//jshortArray (*NewShortArray)(JNIEnv *, jsize);
//jintArray (*NewIntArray)(JNIEnv *, jsize);
//jlongArray (*NewLongArray)(JNIEnv *, jsize);
//jfloatArray (*NewFloatArray)(JNIEnv *, jsize);
//jdoubleArray (*NewDoubleArray)(JNIEnv *, jsize);
//
//
///**
// * NativeType *Get<PrimitiveType>ArrayElements(JNIEnv *env, ArrayType array, jboolean *isCopy);
// * 返回基本类型数组中的数据，通过返回的指针可以访问这些数据，若虚拟机支持pinning，则指针指向原始数组，否则指向原始数组的拷贝
// * 返回的指针在Release<PrimitiveType>ArrayElements()调用前一直有效
// * 数组用使用结束后，调用Release<PrimitiveType>ArrayElements，并在调用参数中决定是否把修改提交给java
// *
// * @param env JNI接口指针
// * @param array java数组
// * @param isCopy 指向boolean的指针，若不为NULL，则执行了复制设为JNI_TRUE，否则设为JNI_FALSE
// *
// * @return 指向数组元素的指针 or NULL
// */
//jboolean *(*GetBooleanArrayElements)(JNIEnv *, jbooleanArray, jboolean *);
//jbyte *(*GetByteArrayElements)(JNIEnv *, jbyteArray, jboolean *);
//jchar *(*GetCharArrayElements)(JNIEnv *, jcharArray, jboolean *);
//jshort *(*GetShortArrayElements)(JNIEnv *, jshortArray, jboolean *);
//jint *(*GetIntArrayElements)(JNIEnv *, jintArray, jboolean *);
//jlong *(*GetLongArrayElements)(JNIEnv *, jlongArray, jboolean *);
//jfloat *(*GetFloatArrayElements)(JNIEnv *, jfloatArray, jboolean *);
//jdouble *(*GetDoubleArrayElements)(JNIEnv *, jdoubleArray, jboolean *);
//
//
///**
// * Release<PrimitiveType>ArrayElements
// * 通知VM不再需要访问这些数组，根据mode参数的不同，将决定是否把数组的修改复制到源数组
// *
// * @param env JNI接口指针
// * @param array java数组对象
// * @param elems 指向数组元素的指针
// * @param mode 释放模式，0：把数据复制回源数组并释放elems缓冲区，JNI_COMMIT：把数据复制回源数组但不释放elems缓冲区，JNI_ABORT：不把数据复制回源数组，释放elems缓冲区
// */
//void (*ReleaseBooleanArrayElements)(JNIEnv *, jbooleanArray, jboolean *, jint);
//void (*ReleaseByteArrayElements)(JNIEnv *, jbyteArray, jbyte *, jint);
//void (*ReleaseCharArrayElements)(JNIEnv *, jcharArray, jchar *, jint);
//void (*ReleaseShortArrayElements)(JNIEnv *, jshortArray, jshort *, jint);
//void (*ReleaseIntArrayElements)(JNIEnv *, jintArray, jint *, jint);
//void (*ReleaseLongArrayElements)(JNIEnv *, jlongArray, jlong *, jint);
//void (*ReleaseFloatArrayElements)(JNIEnv *, jfloatArray, jfloat *, jint);
//void (*ReleaseDoubleArrayElements)(JNIEnv *, jdoubleArray, jdouble *, jint);
//
//
///**
// * void Get<PrimitiveType>ArrayRegion(JNIEnv *env, ArrayType array, jsize start, jsize len, NativeType *buf);
// * 把基本类型数组拷贝到buf中
// *
// * @param env JNI接口指针
// * @param array java数组
// * @param start 开始index
// * @param len 拷贝长度
// * @param buf 目标地址
// *
// * @throws ArrayIndexOutOfBoundsException
// */
//void (*GetBooleanArrayRegion)(JNIEnv *, jbooleanArray, jsize, jsize, jboolean *);
//void (*GetByteArrayRegion)(JNIEnv *, jbyteArray, jsize, jsize, jbyte *);
//void (*GetCharArrayRegion)(JNIEnv *, jcharArray, jsize, jsize, jchar *);
//void (*GetShortArrayRegion)(JNIEnv *, jshortArray, jsize, jsize, jshort *);
//void (*GetIntArrayRegion)(JNIEnv *, jintArray, jsize, jsize, jint *);
//void (*GetLongArrayRegion)(JNIEnv *, jlongArray, jsize, jsize, jlong *);
//void (*GetFloatArrayRegion)(JNIEnv *, jfloatArray, jsize, jsize, jfloat *);
//void (*GetDoubleArrayRegion)(JNIEnv *, jdoubleArray, jsize, jsize, jdouble *);
//
//
///**
// * void Set<PrimitiveType>ArrayRegion(JNIEnv *env, ArrayType array, jsize start, jsize len, const NativeType *buf);
// * 把buf中的内容拷贝回数组中
// *
// * @param env JNI接口指针
// * @param array java数组
// * @param start 开始index
// * @param len 拷贝长度
// * @param buf 源数据
// *
// * @throws ArrayIndexOutOfBoundsException
// */
//void (*SetBooleanArrayRegion)(JNIEnv *, jbooleanArray, jsize, jsize, const jboolean *);
//void (*SetByteArrayRegion)(JNIEnv *, jbyteArray, jsize, jsize, const jbyte *);
//void (*SetCharArrayRegion)(JNIEnv *, jcharArray, jsize, jsize, const jchar *);
//void (*SetShortArrayRegion)(JNIEnv *, jshortArray, jsize, jsize, const jshort *);
//void (*SetIntArrayRegion)(JNIEnv *, jintArray, jsize, jsize, const jint *);
//void (*SetLongArrayRegion)(JNIEnv *, jlongArray, jsize, jsize, const jlong *);
//void (*SetFloatArrayRegion)(JNIEnv *, jfloatArray, jsize, jsize, const jfloat *);
//void (*SetDoubleArrayRegion)(JNIEnv *, jdoubleArray, jsize, jsize, const jdouble *);
//
//
///**
// * 为clazz类注册本地方法
// *
// * @param env JNI接口指针
// * @param clazz class对象
// * @param methods clazz类中的本地方法，指向方法数组
// * @param nMethods 本地方法个数
// *
// * @return 0：成功， 负数：失败
// *
// * @throws NoSuchMethodError
// */
//jint (*RegisterNatives)(JNIEnv *, jclass, const JNINativeMethod *, jint);
//
//
///**
// * 取消clazz类本地方法的注册
// *
// * @param env JNI接口指针
// * @param clazz class对象
// *
// * @return 0：成功， 负数：失败
// */
//jint (*UnregisterNatives)(JNIEnv *, jclass);
//
//
///**
// * 进入与obj所引用的Java对象相关联的监控，obj 必须为非空
// *
// * @param env JNI接口指针
// * @param obj java对象 或 class对象
// *
// * @return 0：成功， 负数：失败
// */
//jint (*MonitorEnter)(JNIEnv *, jobject);
//
//
///**
// * 退出与obj所引用的Java对象相关联的监控，obj 必须为非空
// * 当前线程必须是与obj所引用的Java对象相关联的监控程序的所有者
// * 监控程序次数的计数器减 1。如果计数器的值变为 0，则释放当前线程的监控程序
// *
// * @param env JNI接口指针
// * @param obj java对象 或 class对象
// *
// * @return 0：成功， 负数：失败
// */
//jint (*MonitorExit)(JNIEnv *, jobject);
//
//
///**
// * 获取当前线程关联的Java VM接口
// *
// * @param env JNI接口指针
// * @param vm java VM接口指针
// *
// * @return 0：成功， 负数：失败
// */
//jint (*GetJavaVM)(JNIEnv *, JavaVM **);
//
//
///**
// * 从start index开始，拷贝len个Unicode字符到buf
// *
// * @param env JNI接口指针
// * @param str string对象
// * @param start 开始index
// * @param len 拷贝长度
// * @param buf 目标地址
// *
// * @throws StringIndexOutOfBoundsException
// */
//void (*GetStringRegion)(JNIEnv *, jstring, jsize, jsize, jchar *);
//
//
///**
// * 从start index开始，取出len个Unicode字符转换为UTF-8编码后拷贝到buf
// *
// * @param env JNI接口指针
// * @param str string对象
// * @param start 开始index
// * @param len 拷贝长度
// * @param buf 目标地址
// *
// * @throws StringIndexOutOfBoundsException
// */
//void (*GetStringUTFRegion)(JNIEnv *, jstring, jsize, jsize, char *);
//
//
///**
// * 与Get/Release<primitivetype>ArrayElements方法非常相似，在这个方法中VM尽量返回指向原始数组的指针
// *
// * @since JDK/JRE 1.2
// *
// * @param env JNI接口指针
// * @param array java数组
// * @param isCopy 指向boolean的指针，若不为NULL，则执行了复制设为JNI_TRUE，否则设为JNI_FALSE
// *
// * @return 指向数组元素的指针 or NULL
// */
//void *(*GetPrimitiveArrayCritical)(JNIEnv *, jarray, jboolean *);
//void (*ReleasePrimitiveArrayCritical)(JNIEnv *, jarray, void *, jint);
//
//
///**
// * 与Get/ReleaseStringChars方法非常相似，在这个方法中VM尽量返回指向原始字符串的指针
// *
// * @since JDK/JRE 1.2
// *
// * @param env JNI接口指针
// * @param string String对象
// * @param isCopy 指向boolean的指针
// *
// * @return 指向字符串的指针 or NULL
// */
//const jchar *(*GetStringCritical)(JNIEnv *, jstring, jboolean *);
//void (*ReleaseStringCritical)(JNIEnv *, jstring, const jchar *);
//
//
///**
// * 为传入的obj创建弱全局引用
// * 弱全局引用不会阻止VM释放所引用的对象，程序中可以通过使用IsSameObject比较弱全局引用和NULL来确认所引用的对象是否被释放
// *
// * @param env JNI接口指针
// * @param obj 全局或局部引用
// *
// * @return 弱全局引用 or NULL
// */
//jweak (*NewWeakGlobalRef)(JNIEnv *, jobject);
//
//
///**
// * 删除弱全局引用
// *
// * @param env JNI接口指针
// * @param obj 弱全局引用
// */
//void (*DeleteWeakGlobalRef)(JNIEnv *, jweak);
//
//
///**
// * 判断是否有未处理异常
// *
// * @param env JNI接口指针
// *
// * @return JNI_TRUE表示有未处理异常，否则为JNI_FALSE
// */
//jboolean (*ExceptionCheck)(JNIEnv *);
//
//
///**
// * 创建并返回java.nio.ByteBuffer对象，该对象引用以address为开始地址，大小为capacity的内存块
// *
// * @since JDK/JRE 1.4
// *
// * @param env JNI接口指针
// * @param address 开始地址
// * @param capacity 内存大小
// *
// * @return Jjava.nio.ByteBuffer or NULL
// *
// * @throws OutOfMemoryError
// */
//jobject (*NewDirectByteBuffer)(JNIEnv *, void *, jlong);
//
//
///**
// * 根据java.nio.ByteBuffer对象，获取相应的内存数据并返回开始地址
// *
// * @since JDK/JRE 1.4
// *
// * @param env JNI接口指针
// * @param buf java.nio.ByteBuffer对象
// *
// * @return 数据的开始地址 or NULL
// */
//void *(*GetDirectBufferAddress)(JNIEnv *, jobject);
//
//
///**
// * 根据java.nio.ByteBuffer对象，获取相应的内存数据的大小
// *
// * @since JDK/JRE 1.4
// *
// * @param env JNI接口指针
// * @param buf java.nio.ByteBuffer对象
// *
// * @return 数据大小 or -1
// */
//jlong (*GetDirectBufferCapacity)(JNIEnv *, jobject);
//
//
///**
// * 获取java对象的引用类型，可能的返回值有：
// * JNIInvalidRefType
// * JNILocalRefType：局部引用
// * JNIGlobalRefType：全局引用
// * JNIWeakGlobalRefType ：全局弱若引用
// *
// * @since JDK/JRE 1.6
// *
// * @param env JNI接口指针
// * @param obj java对象的引用
// *
// * @return 引用类型
// */
//jobjectRefType (*GetObjectRefType)(JNIEnv *, jobject);